﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Drawing;
using System.IO;
using System.ComponentModel;

namespace GIFT
{
    public class ControlInterfaz
    {
        //Constructor de la clase
        public ControlInterfaz(InterfazPrincipal VPrincipal)
        {
            Principal = VPrincipal;
        }

        //Retorna la ventana principal
        public InterfazPrincipal getPrincipal()
        {
            return Principal;
        }

        //Llena el treeview con los nombres de los tipos de campo existentes
        public void LlenarTreeView(ContextMenuStrip clickDerechoTipoCampo)
        {
            Principal.GetTreeView().BeginUpdate();
            string[] Componentes = { "tipoCampo", "formulario", "comando", "actividad", "flujoTrabajo" };
            TreeNodeCollection component = Principal.GetTreeView().Nodes[0].Nodes;
            for (int i = 0; i < component.Count; ++i)
            {
                Principal.GetTreeView().SelectedNode = component[i];
                AgregaNodosComponentes(Componentes[i],clickDerechoTipoCampo );
            }
            Principal.GetTreeView().EndUpdate();
            Principal.GetTreeView().Refresh();
        }


        //Agrega nodos al arbol principal del form
        //Agrega nodos al arbol principal del form
        private void AgregaNodosComponentes(string componente, ContextMenuStrip clickDerechoTipoCampo)
        {
            if (componente == "tipoCampo")
            {
                string[] TiposCampo = { "numero", "binario", "incremental", "texto", "fechaHora", "jerarquia", "lista" };
                TreeNodeCollection tCampo = Principal.GetTreeView().Nodes[0].Nodes[0].Nodes;
                for (int i = 0; i < tCampo.Count; ++i)
                {
                    Principal.GetTreeView().SelectedNode = tCampo[i];
                    agregarInstanciasComponentes(TiposCampo[i], clickDerechoTipoCampo);
                }
            }
            else
            {
                agregarInstanciasComponentes(componente, clickDerechoTipoCampo);
            }
        }

        //Agrega nodos con los nombres de las instancias de los componentes
        private void agregarInstanciasComponentes(string instancia, ContextMenuStrip clickDerechoTipoCampo)
        {
            ArrayList campos = obtenerListaCampos(instancia);
            for (int i = 0; i < campos.Count; ++i)
            {
                TreeNode tnode = new TreeNode(campos[i].ToString());
                tnode.ContextMenuStrip = clickDerechoTipoCampo;
                Principal.GetTreeView().SelectedNode.Nodes.Add(tnode);
            }
        }

        //Abre un tipo de campo para mostrar la informacion en la pantalla principal,recibe el nombre del campo, el tipo
        public Form abrirArchivo(String nombre, String tipo)
        {
            Form retorno = null;
            switch (tipo)
            {
                case ("numero"):
                    VentanaNumero nuevoNumero = new VentanaNumero(nombre, Principal);
                    ControlNumero num = new ControlNumero();
                    nuevoNumero.setCorrelativo(num.obtenerAtributo(nombre, "correlativo"));
                    nuevoNumero.setNombre(nombre);
                    nuevoNumero.setDescripcion(num.obtenerAtributo(nombre, "descripcion"));
                    nuevoNumero.setActualizacion(num.obtenerAtributo(nombre, "fecha_actualizacion"));
                    nuevoNumero.setMascara(num.obtenerAtributo(nombre, "mascara"));
                    nuevoNumero.setDecimales(num.obtenerAtributo(nombre, "[numero de decimales]"));
                    nuevoNumero.setDefecto(num.obtenerAtributo(nombre, "[valor por defecto]"));
                    retorno = nuevoNumero;
                    break;
                case ("binario"):
                    VentanaBinario nuevaBinario = new VentanaBinario(nombre, Principal);
                    ControlBinario bin = new ControlBinario();
                    nuevaBinario.setCorrelativo(bin.obtenerAtributo(nombre, "correlativo"));
                    nuevaBinario.setNombre(nombre);
                    nuevaBinario.setDescripcion(bin.obtenerAtributo(nombre, "descripcion"));
                    nuevaBinario.setActualizacion(bin.obtenerAtributo(nombre, "fecha_actualizacion"));
                    nuevaBinario.setNombre1(bin.obtenerAtributo(nombre, "nombre opción 1"));
                    nuevaBinario.setValor1(bin.obtenerAtributo(nombre, "valor opción 1"));
                    nuevaBinario.setNombre2(bin.obtenerAtributo(nombre, "nombre opción 2"));
                    nuevaBinario.setValor2(bin.obtenerAtributo(nombre, "valor opción 2"));
                    nuevaBinario.setDefecto(bin.obtenerAtributo(nombre, "valor por defecto"));
                    retorno = nuevaBinario;
                    break;
                case ("incremental"):
                    VentanaIncremental nuevaPestanaIncremental = new VentanaIncremental(nombre, Principal);
                    ControlIncremental inc = new ControlIncremental();
                    nuevaPestanaIncremental.setCorrelativo(inc.obtenerAtributo(nombre, "correlativo"));
                    nuevaPestanaIncremental.setNombre(nombre);
                    nuevaPestanaIncremental.setDescripcion(inc.obtenerAtributo(nombre, "descripcion"));
                    nuevaPestanaIncremental.setActualizacion(inc.obtenerAtributo(nombre, "fecha_actualizacion"));
                    nuevaPestanaIncremental.setValorInicial(inc.obtenerAtributo(nombre, "[valor inicial]"));
                    nuevaPestanaIncremental.setIncremento(inc.obtenerAtributo(nombre, "incremento"));
                    retorno = nuevaPestanaIncremental;
                    break;
                case ("texto"):
                    VentanaTexto nueva_pestana_Texto = new VentanaTexto(nombre, Principal);
                    ControlTexto text = new ControlTexto();
                    nueva_pestana_Texto.setCorrelativo(text.obtenerAtributo(nombre, "correlativo"));
                    nueva_pestana_Texto.setNombre(nombre);
                    nueva_pestana_Texto.setDescripcion(text.obtenerAtributo(nombre, "descripcion"));
                    nueva_pestana_Texto.setActualizacion(text.obtenerAtributo(nombre, "fecha_actualizacion"));
                    nueva_pestana_Texto.setLargo(text.obtenerAtributo(nombre, "largo"));
                    nueva_pestana_Texto.setDefecto(text.obtenerAtributo(nombre, "[texto por defecto]"));
                    retorno = nueva_pestana_Texto;
                    break;
                case ("fechaHora"):
                    VentanaFechaHora nuevaFecha = new VentanaFechaHora(nombre, Principal);
                    ControlFechaHora fecha = new ControlFechaHora();
                    nuevaFecha.setCorrelativo(fecha.obtenerAtributo(nombre, "correlativo"));
                    nuevaFecha.setNombre(nombre);
                    nuevaFecha.setDescripcion(fecha.obtenerAtributo(nombre, "descripcion"));
                    nuevaFecha.setActualizacion(fecha.obtenerAtributo(nombre, "fecha_actualizacion"));
                    nuevaFecha.setDespliegueFecha(fecha.obtenerAtributo(nombre, "formato despliegue"));//formato
                    nuevaFecha.setFechaDefecto(fecha.obtenerAtributo(nombre, "fecha por defecto"));//la fecha
                    nuevaFecha.setVencimiento(fecha.obtenerAtributo(nombre, "con vencimiento"));
                    nuevaFecha.setPreaviso(fecha.obtenerAtributo(nombre, "preaviso"));
                    retorno = nuevaFecha;
                    break;
                case ("jerarquia"):
                    VentanaJerarquia nuevaJerarquia = new VentanaJerarquia(nombre, Principal);
                    ControlJerarquia jer = new ControlJerarquia();
                    //Llena los campos principales
                    nuevaJerarquia.llenarListaPrincipalCategorias(jer.obtenerListaCategorias()); //Llena la lista principal de categorias
                    nuevaJerarquia.llenarListaPrincipalNiveles(jer.obtenerListaNiveles());//Llena la lista principal de niveles
                    nuevaJerarquia.llenarNumeroNiveles(jer.obtenerNumeroNiveles(nombre));
                    nuevaJerarquia.setCorrelativo(jer.obtenerAtributoJerarquia(nombre, "correlativo"));
                    nuevaJerarquia.setNombre(nombre);
                    nuevaJerarquia.setDescripcion(jer.obtenerAtributoJerarquia(nombre, "descripcion"));
                    nuevaJerarquia.setActualizacion(jer.obtenerAtributoJerarquia(nombre, "fecha_actualizacion"));
                    nuevaJerarquia.setCreacion(jer.obtenerAtributoJerarquia(nombre, "[fecha creacion]"));
                    nuevaJerarquia.setNumTerminos(jer.obtenerAtributoJerarquia(nombre, "[numero terminos]"));
                    nuevaJerarquia.setNumNiveles(jer.obtenerAtributoJerarquia(nombre, "[numero niveles]"));
                    nuevaJerarquia.setConVersion(jer.estaHabilitadoAtributoJerarquia(nombre, "[con version]"));
                    nuevaJerarquia.setConCategorias(jer.estaHabilitadoAtributoJerarquia(nombre, "[con categorias]"));
                    nuevaJerarquia.setConNiveles(jer.estaHabilitadoAtributoJerarquia(nombre, "[con niveles]"));
                    nuevaJerarquia.setNombrePorNivel(jer.estaHabilitadoAtributoJerarquia(nombre, "[con Nombre Nivel]"));
                    nuevaJerarquia.llenarArbolJerarquia(); //llena el arbol
                    if (nuevaJerarquia.getConCategorias())//Si tiene categorias
                    {
                        nuevaJerarquia.llenarListaCategoriasTermino(jer.obtenerListaCategoriasDeTerminos(nombre));//Llena la lista de categorias para los terminos
                        nuevaJerarquia.setListaPrincipalCategorias(jer.obtenerCategoriaJerarquia(nombre));
                    }
                    if (nuevaJerarquia.getConNiveles())//Si tiene niveles 
                    {
                        if (nuevaJerarquia.getNombrePorNivel())//Si tiene nombre por nivel
                        {
                            nuevaJerarquia.llenarListaNivelesTermino(jer.obtenerListaNivelesDeTerminos(nombre)); //Llena la lista de los nombres de niveles para termino
                            nuevaJerarquia.setListaPrincipalNiveles(jer.obtenerNivelJerarquia(nombre));
                        }
                    }
                    retorno = nuevaJerarquia;
                    break;
                case ("lista"):
                    VentanaLista nueva_pestana_Lista = new VentanaLista(nombre, Principal);
                    ControlLista list = new ControlLista();
                    nueva_pestana_Lista.setCorrelativo(list.obtenerAtributo(nombre, "correlativo"));
                    nueva_pestana_Lista.setNombre(nombre);
                    nueva_pestana_Lista.setDescripcion(list.obtenerAtributo(nombre, "descripcion"));
                    nueva_pestana_Lista.setActualizacion(list.obtenerAtributo(nombre, "fecha_actualizacion"));
                    nueva_pestana_Lista.setOrden(list.obtenerAtributo(nombre, "ordenada"));
                    String idDefecto = list.obtenerAtributo(nombre, "defecto");
                    if (idDefecto != "") { nueva_pestana_Lista.setDefecto(list.obtieneDefectoLista(idDefecto)); }
                    nueva_pestana_Lista.setLista(list.obtieneTerminosLista(list.obtenerAtributo(nombre, "correlativo")));
                    retorno = nueva_pestana_Lista;
                    break;
                case ("formulario"):
                    VentanaFormulario nuevoFormulario = new VentanaFormulario(nombre, Principal);
                    ControlFormulario controlFormulario = new ControlFormulario();
                    ArrayList atributos = controlFormulario.obtieneAtributosFormulario(nombre);
                    if (atributos != null)
                    {
                        nuevoFormulario.setNombre(atributos[1].ToString());
                        nuevoFormulario.setDescripcion(atributos[2].ToString());
                        nuevoFormulario.setActualizacion(atributos[3].ToString());
                        nuevoFormulario.setCoordenadaX(atributos[4].ToString());
                        nuevoFormulario.setCoordenadaY(atributos[5].ToString());

                        object x = controlFormulario.obtieneIcono(nombre);
                        
                        if (x.ToString() != "") 
                        {
                            Icon icono;
                            MemoryStream y = new MemoryStream((byte[])x);
                            Bitmap img = new Bitmap(y);
                            icono = Icon.FromHandle(img.GetHicon());
                            nuevoFormulario.setIcono(icono);
                            // Foto.Image = img;
                        }
                            

                        nuevoFormulario.cargaComponentes(atributos[1].ToString());
                    }

                    retorno = nuevoFormulario;
                    break;
                case ("comando"):
                    ArrayList formularios = new ControlFormulario().obtenerFormularios();
                    VentanaComando cmd = new VentanaComando(nombre, Principal, formularios);
                    ControlComando controlcomando = new ControlComando();
                    String tipoComando = controlcomando.retornaTipo(nombre);
                    switch (tipoComando)
                    {
                        case "con mascara":
                            cmd.setComandoMascara(controlcomando.obtieneComandoConMascara(nombre));
                            break;
                        case "sin mascara":
                            cmd.setComandoSinMascara(controlcomando.obtieneComandoSinMascara(nombre));
                            break;
                        case "busqueda":
                            cmd.setComandoBusqueda(controlcomando.obtieneComandoBusqueda(nombre));
                            break;
                    }
                    retorno = cmd;
                    break;
                case ("actividad"):
                    ArrayList comandos = new ControlComando().obtenerComandos();
                    VentanaActividad act = new VentanaActividad(nombre, Principal, comandos);
                    ControlActividad controlactividad = new ControlActividad();
                    //FALTA//*********************
                    retorno = act;
                    break;
            }
                      
            return retorno;
        }

        //Retorna una ventana con los datos de un nuevo tipo de campo, si no se puede crear retorna null
        public Form abrirArchivoNuevo(String nombre, String descripcion, String tipo)
        {
            Form retorno = null;
            switch (tipo)
            {
                case ("numero"):
                    ControlNumero num = new ControlNumero();
                    if (!num.existe(nombre))// Si el nombre no existe
                    {
                        VentanaNumero nuevaNumero = new VentanaNumero(nombre, Principal);
                        nuevaNumero.setDescripcion(descripcion);
                        retorno = nuevaNumero;
                    }
                    break;
                case ("binario"):
                    ControlBinario bin = new ControlBinario();
                    if (!bin.existe(nombre))// Si el nombre no existe
                    {
                        VentanaBinario nuevaBinario = new VentanaBinario(nombre, Principal);
                        nuevaBinario.setDescripcion(descripcion);
                        retorno = nuevaBinario;
                    }
                    break;
                case ("incremental"):
                    ControlIncremental inc = new ControlIncremental();
                    if (!inc.existe(nombre))// Si el nombre no existe
                    {
                        VentanaIncremental nuevaIncremental = new VentanaIncremental(nombre, Principal);
                        nuevaIncremental.setDescripcion(descripcion);
                        retorno = nuevaIncremental;
                    }
                    break;
                case ("texto"):
                    ControlTexto text = new ControlTexto();
                    if (!text.existe(nombre))// Si el nombre no existe
                    {
                        VentanaTexto nuevaTexto = new VentanaTexto(nombre, Principal);
                        nuevaTexto.setDescripcion(descripcion);
                        retorno = nuevaTexto;
                    }
                    break;
                case ("fechaHora"):
                    ControlFechaHora fec = new ControlFechaHora();
                    if (!fec.existe(nombre))// Si el nombre no existe
                    {
                        VentanaFechaHora nuevaFecha = new VentanaFechaHora(nombre, Principal);
                        nuevaFecha.setDescripcion(descripcion);
                        retorno = nuevaFecha;
                    }
                    break;
                case ("jerarquia"):
                    ControlJerarquia jer = new ControlJerarquia();
                    if (!jer.existeJerarquia(nombre))// Si el nombre no existe
                    {
                        VentanaJerarquia nuevaJerarquia = new VentanaJerarquia(nombre, Principal);
                        nuevaJerarquia.setDescripcion(descripcion);
                        jer.crearNuevaJerarquia(nombre, descripcion); //Se crea una nueva (Problema con el trabajo de terminos por lo tanto debe de existir la jerarquia)
                        retorno = nuevaJerarquia;
                    }
                    break;
                case ("lista"):
                    ControlLista lista = new ControlLista();
                    if (!lista.existe(nombre))// Si el nombre no existe
                    {
                        VentanaLista nuevaLista = new VentanaLista(nombre, Principal);
                        nuevaLista.setDescripcion(descripcion);
                        lista.crearNuevo(nombre, descripcion, nuevaLista.getOrden());
                        nuevaLista.setCorrelativo(lista.obtenerAtributo(nombre, "correlativo"));
                        retorno = nuevaLista;
                    }
                    break;
                case ("formulario"):
                    ControlFormulario formul = new ControlFormulario();
                    if (!formul.verificaExistenciaFormulario(nombre))// Si el nombre no existe
                    {
                        VentanaFormulario nuevoFormulario = new VentanaFormulario(nombre, Principal);
                        nuevoFormulario.setDescripcion(descripcion);
                        formul.guardarFormulario(nombre, descripcion, nuevoFormulario.getCoordenadaX(), nuevoFormulario.getCoordenadaY());
                        //nuevoFormulario.habilitacionBotonAbrirFormulario(true);
                        retorno = nuevoFormulario;
                    }
                    break;
                case ("comando"):
                    ControlComando cmd = new ControlComando();
                    if (!cmd.existe(nombre))// Si el nombre no existe
                    {
                        VentanaComando nuevoComando = new VentanaComando(nombre, Principal, new ControlFormulario().obtenerFormularios());
                        Comando nuevo = new Comando(nombre, descripcion, DateTime.Now.ToString());
                        nuevoComando.setComando(nuevo);
                        retorno = nuevoComando;
                    }
                    break;
                case ("actividad"):
                    ControlActividad cmdA = new ControlActividad();
                    if (!cmdA.existe(nombre))// Si el nombre no existe
                    {
                        VentanaActividad nuevaActividad = new VentanaActividad(nombre, Principal, new ControlComando().obtenerComandos());
                        Actividad nuevaAct = new Actividad(nombre, descripcion, DateTime.Now.ToString());
                        nuevaActividad.setActividad(nuevaAct);
                        retorno = nuevaActividad;
                    }
                    break;
            }
            return retorno;
        }

        //Retorna una DataGridView con todos los campos que tienen en sus campos la hilera que recibe como parametro
        public DataGridView HacerBusqueda(String aBuscar, DataGridView ventana)
        {
            //Se hace para el numero
            ControlNumero num = new ControlNumero();
            ArrayList numeros = num.buscarContenido(aBuscar);
            ArrayList descripciones = new ArrayList();
            for (int i = 0; i < numeros.Count; ++i)
            {
                descripciones.Add(num.obtenerAtributo(numeros[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "numero", numeros, descripciones);
            
            //Se hace para el binario
            descripciones.Clear();
            ControlBinario bin = new ControlBinario();
            ArrayList binarios = bin.buscarContenido(aBuscar);
            for (int i = 0; i < binarios.Count; ++i)
            {
                descripciones.Add(bin.obtenerAtributo(binarios[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "binario", binarios, descripciones);

            //Se hace para el incremental
            descripciones.Clear();
            ControlIncremental inc = new ControlIncremental();
            ArrayList incrementales = inc.buscarContenido(aBuscar);
            for (int i = 0; i < incrementales.Count; ++i)
            {
                descripciones.Add(inc.obtenerAtributo(incrementales[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "incremental", incrementales, descripciones);

            //Se hace para el fechaHora
            descripciones.Clear();
            ControlFechaHora fecha = new ControlFechaHora();
            ArrayList fechas = fecha.buscarContenido(aBuscar);
            descripciones.Clear();
            for (int i = 0; i < fechas.Count; ++i)
            {
                descripciones.Add(fecha.obtenerAtributo(fechas[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "fechaHora", fechas, descripciones);

            //Se hace para el texto
            descripciones.Clear();
            ControlTexto tex = new ControlTexto();
            ArrayList textos = tex.buscarContenido(aBuscar);
            for (int i = 0; i < textos.Count; ++i)
            {
                descripciones.Add(tex.obtenerAtributo(textos[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "texto", textos, descripciones);

            //Se hace para lista
            descripciones.Clear();
            ControlLista list = new ControlLista();
            ArrayList listas = list.buscarContenido(aBuscar);
            for (int i = 0; i < listas.Count; ++i)
            {
                descripciones.Add(list.obtenerAtributo(listas[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "lista", listas, descripciones);

            //Se hace para la jerarquia
            descripciones.Clear();
            ControlJerarquia jer = new ControlJerarquia();
            ArrayList jerarquias = jer.buscarContenidoEnJerarquia(aBuscar);
            for (int i = 0; i < jerarquias.Count; ++i)
            {
                descripciones.Add(jer.obtenerAtributoJerarquia(jerarquias[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "jerarquia", jerarquias, descripciones);

            //Se hace para la lista
            descripciones.Clear();

            //Se hace para formularios
            descripciones.Clear();
            ControlFormulario formul = new ControlFormulario();
            ArrayList formularios = formul.buscarContenido(aBuscar);
            for (int i = 0; i < formularios.Count; ++i)
            {
                descripciones.Add(formul.obtieneAtributoEspecificoTabla("formulario", "descripcion", "nombre", "'" + formularios[i].ToString() + "'"));
            }
            AgregarAlGrid(ventana, "formulario", formularios, descripciones);

            //Se hace para comandos
            descripciones.Clear();
            ControlComando coman = new ControlComando();
            ArrayList comandos = coman.buscarContenido(aBuscar);
            for (int i = 0; i < comandos.Count; ++i)
            {
                descripciones.Add(formul.obtieneAtributoEspecificoTabla("comando", "descripcion", "nombre", "'" + comandos[i].ToString() + "'"));
            }
            AgregarAlGrid(ventana, "comando", comandos, descripciones);

            //Se hace para actividades
            descripciones.Clear();
            ControlActividad actv = new ControlActividad();
            ArrayList actividades = actv.buscarContenido(aBuscar);
            for (int i = 0; i < actividades.Count; ++i)
            {
                descripciones.Add(actv.obtenerAtributo(actividades[i].ToString(), "descripcion"));
            }
            AgregarAlGrid(ventana, "actividad", actividades, descripciones);


            return ventana;
        }

        //Agrega los datos al grid
        private void AgregarAlGrid(DataGridView ventana, String NombreTipoCampo,ArrayList campos, ArrayList descripciones)
        {
            for (int i = 0; i < campos.Count; ++i)
            {
                DataGridViewRow fila = new DataGridViewRow();
                fila.CreateCells(ventana, new object[] { NombreTipoCampo, campos[i], descripciones[i]});
                ventana.Rows.Add(fila);
            }
        }

        //Obtiene los nombres de todos los tipo numero que existen
        public ArrayList obtenerListaCampos(String tipoCampo)
        {
            ArrayList nombres = new ArrayList();
            switch (tipoCampo)//Pregunta cual tipo de campo es
            {
                case ("numero"):
                    ControlNumero num = new ControlNumero();
                    nombres = num.obtenerNumeros();
                    break;
                case ("binario"):
                    ControlBinario bin = new ControlBinario();
                    nombres = bin.obtenerBinarios();
                    break;
                case ("incremental"):
                    ControlIncremental inc = new ControlIncremental();
                    nombres = inc.obtenerIncremental();
                    break;
                case ("texto"):
                    ControlTexto tex = new ControlTexto();
                    nombres = tex.obtenerTextos();
                    break;
                case ("fechaHora"):
                    ControlFechaHora fec = new ControlFechaHora();
                    nombres = fec.obtenerFechas();
                    break;
                case ("jerarquia"):
                    ControlJerarquia jer = new ControlJerarquia();
                    nombres = jer.obtenerJerarquias();
                    break;
                case ("lista"):
                    ControlLista lis = new ControlLista();
                    nombres = lis.obtenerListas();
                    break;
                case ("formulario"):
                    ControlFormulario formul = new ControlFormulario();
                    nombres = formul.obtenerFormularios();
                    break;
                case ("comando"):
                    ControlComando coman = new ControlComando();
                    nombres = coman.obtenerComandos();
                    break;
                case ("actividad"):
                    ControlActividad actv = new ControlActividad();
                    nombres = actv.obtenerActividades();
                    break;
            }
            return nombres;
        }


        //Obtiene los datos de lo que se desea imprimir
        public String ObtenerDatosImprimir(String tipo, Form ventana)
        {
            String retorno = "";
            switch (tipo)
            {
                case ("numero"):
                    VentanaNumero numero = (VentanaNumero)ventana;
                        //Saca y retorna la informacion
                    retorno = ("***GIFT***\n NÚMERO\n\nCorrelativo:\n\t" + numero.getCorrelativo() + "\nNombre:\n\t" + numero.getNombre() + "\nDescripción:\n\t" + numero.getDescripcion() + "\nFecha de Actualización:\n\t" + numero.getActualizacion() + "\nMáscara:\n\t" + numero.getMascara() + "\nCantidad Decimales:\n\t" + numero.getDecimales() + "\nValor por Defecto:\n\t" + numero.getDefecto());
                    break;
                case ("binario"):
                    VentanaBinario binario = (VentanaBinario)ventana;
                    //Saca y retorna la informacion
                    retorno = ("***GIFT***\n BINARIO\n\nCorrelativo:\n\t" + binario.getCorrelativo() + "\nNombre:\n\t" + binario.getNombre() + "\nDescripción:\n\t" + binario.getDescripcion() + "\nNombre opción 1:\n\t" + binario.getNombre1() + "\nValor opción 1:\n\t" + binario.getValor1() + "\nNombre opción 2:\n\t" + binario.getNombre2() + "\nValor opción 2:\n\t" + binario.getValor2() + "\nValor Defecto:\n\t" + binario.getDefecto());
                    break;
                case ("incremental"):
                    VentanaIncremental incremental = (VentanaIncremental)ventana;
                    //Saca y retorna la informacion
                    retorno = ("***GIFT***\n INCREMENTAL\n\nCorrelativo:\n\t" + incremental.getCorrelativo() + "\nNombre:\n\t" + incremental.getNombre() + "\nDescripción:\n\t" + incremental.getDescripcion() + "\nFecha de Actualización:\n\t" + incremental.getActualizacion() + "\nValor Inicial:\n\t" + incremental.getValorInicial() + "\nIncremento:\n\t" + incremental.getIncremento());
                    break;
                case ("texto"):
                    VentanaTexto texto = (VentanaTexto)ventana;
                    //Saca y retorna la informacion
                    retorno = ("***GIFT***\n TEXTO\n\nCorrelativo:\n\t" + texto.getCorrelativo() + "\nNombre:\n\t" + texto.getNombre() + "\nDescripción:\n\t" + texto.getDescripcion() + "\nFecha de Actualización:\n\t" + texto.getActualizacion() + "\nLargo:\n\t" + texto.getLargo() + "\nValor por Defecto:\n\t" + texto.getDefecto());
                    break;
                case ("fechaHora"):
                    VentanaFechaHora fecha = (VentanaFechaHora)ventana;
                    retorno = ("***GIFT***\n FECHA HORA\n\nCorrelativo:\n\t" + fecha.getCorrelativo() + "\nNombre: \n\t" + fecha.getNombre() + "\nDescripcion: \n\t" + fecha.getDescripcion() + "\nFecha Actualización:\n\t" + fecha.getActualizacion() + "\nFormato Despliegue:\n\t" + fecha.getDespliegueFecha() + "\nFecha por defecto: \n\t" + fecha.getFechaDefecto() + "\nCon Vencimiento: \n\t" + fecha.getVencimiento() + "\nPreaviso: \n\t" + fecha.getPreaviso());
                    break;
                case ("jerarquia"):
                    VentanaJerarquia jerarquia = (VentanaJerarquia)ventana;
                    String datos = "";
                    String version = "No", categorias = "No", niveles = "No", nom_unico = "No", nom_nivel = "No";
                    if (jerarquia.getConNiveles())//Si tiene niveles
                    {
                        niveles = "Sí";
                        if (jerarquia.getNombrePorNivel())//Si tiene nombre nivel
                        {
                            nom_nivel = "Si";
                        }
                    }
                    if (jerarquia.getConCategorias())//Si tiene categorias
                    {
                        categorias = "Sí";
                    }
                    if (jerarquia.getConVersion())//Si tiene niveles
                    {
                        version = "Sí";
                    }
                    datos += "***GIFT***\n JERARQUÍA\n\nCorrelativo:\n\t" + jerarquia.getCorrelativo() + "\nNombre:\n\t" + jerarquia.getNombre() + "\nDescripción:\n\t" + jerarquia.getDescripcion() + "\nFecha de Actualización:\n\t" + jerarquia.getActualizacion() + "\nFecha de Creación:\n\t" + jerarquia.getCreacion() + "\nNúmero de Términos:\n\t" + jerarquia.getNumTerminos() + "\nNúmero de Niveles:\n\t" + jerarquia.getNumNiveles() + "\nCategorías:\n\t" + categorias + "\nNiveles:\n\t" + niveles + "\nVersión:\n\t" + version + "\nNombre Único:\n\t" + nom_unico + "\nNombre Por Nivel:\n\t" + nom_nivel;
                    String cadena = jerarquia.LlamadoRecursivo();
                    datos += "\n\n\nVista de " + jerarquia.getNombre() + ":\n\n" + cadena;
                    return datos;
                case ("lista"):
                    VentanaLista lista = (VentanaLista)ventana;
                    retorno = ("***GIFT***\n LISTA\n\nCorrelativo:\n\t" + lista.getCorrelativo() + "\nNombre:\n\t" + lista.getNombre() + "\nDescripción:\n\t" + lista.getDescripcion() + "\nFecha de Actualización:\n\t" + lista.getActualizacion() + "\n\n\nListado:\n\n" + lista.listaTerminos());
                    break;
                case ("formulario"):

                    break;
                case ("comando"):
                    VentanaComando comando = (VentanaComando)ventana;
                    retorno = ("***GIFT***\n COMANDO\n\n Nombre:\n\t" + comando.getNombreComando() + "\nDescripción:\n\t" + comando.getDescripcionComando() + "\nFecha de Actualización:\n\t" + comando.getActualizacionComando() + "\nTipo:\n\t" + comando.getTipo() + "\nFormulario:\n\t" + comando.getValorListaFormulario());
                    switch (comando.getTipo())
                    {
                        case "con mascara":
                            retorno += "\nMascaras:\n\t";
                            ArrayList mascaras = comando.getListaMascaras();
                            for (int i =0; i< mascaras.Count; ++i)
                            {
                                retorno += mascaras[i].ToString() + "\n\t";
                            }
                            break;
                        case "sin mascara":
                            retorno += "\nNivel de derechos:\n\t" + comando.getValorListaNivelDerechos();
                            break;
                        case "busqueda":
                            retorno += "\nBusca en los campos:\n\t";
                            ArrayList filtros = comando.getListaFiltros();
                            for (int i = 0; i < filtros.Count; ++i)
                            {
                                retorno += filtros[i].ToString() + "\n\t";
                            }
                            break;
                    }
                    break;
                case ("actividad"):
                    break;
            }
            return retorno; 
        }

        //Va a guardar un nuevo tipo a partir de otro
        public void guardarNuevo(String tipo, String nuevoNombre, TreeView arbol, ContextMenuStrip clickDerecho, Form ventanaCampo)
        {
            switch (tipo)//Pregunta por el nombre del padre para saber a que tabla pertenece
            {
                case ("numero"):
                    ControlNumero num = new ControlNumero();
                    if (!num.existe(nuevoNombre))//Si el nombre no existe
                    {
                        VentanaNumero numero = (VentanaNumero)ventanaCampo;
                        num.crearNuevo(nuevoNombre, numero.getDescripcion(), numero.getMascara(), numero.getDecimales(), numero.getDefecto());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[0].Nodes.Add(tnode); //Agrega el nodo
                    }
                    else //Si el nombre esta repetido
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    break;
                case ("binario"):
                    ControlBinario bin = new ControlBinario();
                    if (!bin.existe(nuevoNombre))//Si el nombre no existe
                    {
                        VentanaBinario binario = (VentanaBinario)ventanaCampo;
                        bin.crearNuevo(nuevoNombre, binario.getDescripcion(), binario.getNombre1(), binario.getValor1(), binario.getNombre2(), binario.getValor2(), binario.getDefecto());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[1].Nodes.Add(tnode); //Agrega el nodo
                    }
                    else //Si el nombre esta repetido
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    break;
                case ("incremental"):
                    ControlIncremental inc = new ControlIncremental();
                    if (!inc.existe(nuevoNombre))//Si el nombre no existe
                    {
                        VentanaIncremental incremental = (VentanaIncremental)ventanaCampo;
                        inc.crearNuevo(nuevoNombre, incremental.getDescripcion(), incremental.getValorInicial(), incremental.getIncremento());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[2].Nodes.Add(tnode); //Agrega el nodo
                    }
                    else //Si el nombre esta repetido
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    break;
                case ("texto"):
                    ControlTexto tex = new ControlTexto();
                    if (!tex.existe(nuevoNombre))//Si el nombre no existe
                    {
                        VentanaTexto texto = (VentanaTexto)ventanaCampo;
                        tex.crearNuevo(nuevoNombre, texto.getDescripcion(), texto.getLargo(), texto.getDefecto());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[3].Nodes.Add(tnode); //Agrega el nodo
                    }
                    else //Si el nombre esta repetido
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    break;
                case ("fechaHora"):
                    ControlFechaHora fec = new ControlFechaHora();
                    if (!fec.existe(nuevoNombre))//Si el nombre no existe
                    {
                        VentanaFechaHora fecha = (VentanaFechaHora)ventanaCampo;
                        String fechaDefecto = convFechaAGringa(fecha.getFechaDefecto());
                        fec.crearNuevo(nuevoNombre, fecha.getDescripcion(), fecha.getDespliegueFecha(), fechaDefecto, fecha.getVencimiento(), fecha.getPreaviso());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[4].Nodes.Add(tnode); //Agrega el nodo
                    }
                    else //Si el nombre esta repetido
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    break;
                case ("jerarquia"):
                    //manda a modificar la jerarquia
                    ControlJerarquia jer = new ControlJerarquia();
                    if (jer.existeJerarquia(nuevoNombre))//Si el nombre ya existe
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    else //Si se puede agregar
                    {
                        VentanaJerarquia jerarquia = (VentanaJerarquia)ventanaCampo;
                        jer.crearNuevaJerarquia(nuevoNombre, jerarquia.getDescripcion(), jerarquia.getNumTerminos(), jerarquia.getNumNiveles(), jerarquia.getConCategorias(), jerarquia.getConNiveles(), jerarquia.getConVersion(), false, jerarquia.getNombrePorNivel(), jerarquia.getListaPrincipalCategorias(), jerarquia.getListaPrincipalNiveles());
                        jer.copiarTerminosJerarquia(nuevoNombre, jerarquia.getNombre());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[5].Nodes.Add(tnode); //Agrega el nodo
                    }
                    break;
                case ("lista"):
                    //manda a modificar la jerarquia
                    ControlLista list = new ControlLista();
                    if (list.existe(nuevoNombre))//Si el nombre ya existe
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    else //Si se puede agregar
                    {
                        VentanaLista lista = (VentanaLista)ventanaCampo;
                        list.crearNuevo(nuevoNombre, lista.getDescripcion(), lista.getOrden());
                        list.copiarTerminosLista(nuevoNombre, lista.getNombre());
                        list.copiarDefecto(nuevoNombre, lista.getNombre());
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[0].Nodes[6].Nodes.Add(tnode); //Agrega el nodo
                    }
                    break;
                case ("formulario"):
                    //manda a modificar el formulario
                    ControlFormulario formul = new ControlFormulario();
                    if (formul.verificaExistenciaFormulario(nuevoNombre))//Si el nombre ya existe
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    else //Si se puede agregar
                    {
                        VentanaFormulario formulario = (VentanaFormulario)ventanaCampo;//Busca la pestana base
                        formul.guardarFormulario(nuevoNombre, formulario.getDescripcion(), formulario.getCoordenadaX(), formulario.getCoordenadaY());

                        /*todo esto para obtener el tipo del parametro*/
                        if ((formulario.getFoto()).Image != null)
                        {
                            Bitmap bitmap = new Bitmap((formulario.getFoto()).Image);
                            byte[] photo = (byte[])TypeDescriptor.GetConverter(bitmap).ConvertTo(bitmap, typeof(byte[]));
                            formul.guardaIcono(photo, nuevoNombre); //le agrega el icono al nuevo
                        }
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[1].Nodes.Add(tnode); //Agrega el nodo
                        /*solo hasta despues de haber creado el formulario*/
                        formul.clonarComponentes(nuevoNombre, formulario.getNombre());
                    }
                    break;
                case ("comando"):
                    ControlComando cmd = new ControlComando();
                    if (cmd.existe(nuevoNombre))//Si el nombre ya existe
                    {
                        MessageBox.Show("El nombre ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);//informa el error
                        return; //sale 
                    }
                    else //Si se puede agregar
                    {
                        VentanaComando comando = (VentanaComando)ventanaCampo;
                        ControlComando controlComando = new ControlComando();
                        switch (comando.getTipo())
                        {
                            case "con mascara":
                                ComandoMascara nuevo = ((VentanaComando)ventanaCampo).getComandoMascara();
                                nuevo.setNombre(nuevoNombre);
                                nuevo.setId("-1");
                                for (int i = 0; i < nuevo.getMascaras().Count; ++i)
                                {
                                    ((Mascara)nuevo.getMascaras()[i]).setId("-1");
                                }
                                controlComando.guardarConMascara(nuevo);
                                break;
                            case "sin mascara":
                                ComandoSinMascara nuevoSinMascara = ((VentanaComando)ventanaCampo).getComandoSinMascara();
                                nuevoSinMascara.setId("-1");
                                nuevoSinMascara.setNombre(nuevoNombre);
                                controlComando.guardarSinMascara(nuevoSinMascara);
                                break;
                            case "busqueda":
                                ComandoBusqueda nuevoBusqueda = ((VentanaComando)ventanaCampo).getComandoBusqueda();
                                nuevoBusqueda.setId("-1");
                                nuevoBusqueda.setNombre(nuevoNombre);
                                for (int i = 0; i < nuevoBusqueda.getFiltros().Count; ++i)
                                {
                                    ((FiltroBusqueda)nuevoBusqueda.getFiltros()[i]).setId("-1");
                                }
                                controlComando.guardarBusqueda(nuevoBusqueda);
                                break;
                        }
                        TreeNode tnode = new TreeNode(nuevoNombre);
                        tnode.ContextMenuStrip = clickDerecho;
                        arbol.Nodes[0].Nodes[2].Nodes.Add(tnode); //Agrega el nodo
                    }
                    break;

            }
        }

        //Manda a guardar los datos de un archivo
        public void guardarArchivo(Form ventana, String tipo)
        {
            switch (tipo)
            {
                case ("numero"):
                    ((VentanaNumero)ventana).guardarArchivo();
                    break;
                case ("binario"):
                    ((VentanaBinario)ventana).guardarArchivo();
                    break;
                case ("incremental"):
                    ((VentanaIncremental)ventana).guardarArchivo();
                    break;
                case ("texto"):
                    ((VentanaTexto)ventana).guardarArchivo();
                    break;
                case ("fechaHora"):
                    ((VentanaFechaHora)ventana).guardarArchivo();
                    break;
                case ("jerarquia"):
                    ((VentanaJerarquia)ventana).guardarArchivo();
                    break;
                case ("lista"):
                    ((VentanaLista)ventana).guardarArchivo();
                    break;
                case ("formulario"):
                    //LLAMAR AL METODO DE GUARDAR DE FOMULARIO
                    //((VentanaFormulario)ventana).
                    break;
                case ("comando"):
                    ((VentanaComando)ventana).guardarArchivo();
                    break;
                case ("actividad"):
                    ((VentanaActividad)ventana).guardarArchivo();
                    break;
            }
        }

        //Manda a borrar el tipo de campo con el nombre que se ingresaron
        public void borrado(String nombre, String tipo)
        {
            switch (tipo)
            {
                case ("numero"):
                    ControlNumero num = new ControlNumero();
                    num.borrar(nombre);
                    break;
                case ("binario"):
                    ControlBinario bin = new ControlBinario();
                    bin.borrar(nombre);
                    break;
                case ("incremental"):
                    ControlIncremental inc = new ControlIncremental();
                    inc.borrar(nombre);
                    break;
                case ("texto"):
                    ControlTexto tex = new ControlTexto();
                    tex.borrar(nombre);
                    break;
                case ("fechaHora"):
                    ControlFechaHora fec = new ControlFechaHora();
                    fec.borrar(nombre);
                    break;
                case ("jerarquia"):
                    ControlJerarquia jer = new ControlJerarquia();
                    jer.borrarJerarquia(nombre);
                    break;
                case ("lista"):
                    ControlLista list = new ControlLista();
                    list.borrar(nombre);
                    break;
                case ("formulario"):
                    ControlFormulario formul = new ControlFormulario();
                    formul.eliminaFormularios(nombre);
                    break;
                case ("comando"):
                    ControlComando cmd = new ControlComando();
                    cmd.borrar(nombre);
                    break;
                case ("actividad"):
                    ControlActividad act = new ControlActividad();
                    act.borrar(nombre);
                    break;
            }
        }

        //Quita el nodo del arbol, que posee el nombre y el tipo que recibe como parametro
        public void quitarNodo(TreeView treeView, String nombre, String tipo)
        {
            TreeNodeCollection x = null;
            switch (tipo)
            {
                case ("numero"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[0].Nodes ;
                    break;
                case ("binario"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[1].Nodes;
                    break;
                case ("incremental"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[2].Nodes;
                    break;
                case ("texto"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[3].Nodes;
                    break;
                case ("fechaHora"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[4].Nodes;
                    break;
                case ("jerarquia"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[5].Nodes;
                    break;
                case ("lista"):
                    x = treeView.Nodes[0].Nodes[0].Nodes[6].Nodes;
                    break;
                case ("formulario"):
                    x = treeView.Nodes[0].Nodes[1].Nodes;
                    break;
                case ("comando"):
                    x = treeView.Nodes[0].Nodes[2].Nodes;
                    break;
                case ("actividad"):
                    x = treeView.Nodes[0].Nodes[3].Nodes;
                    break;
            }
            int i = 0;
            bool encontrado = false;
            while ((i < x.Count) && (!encontrado))
            {
                if (x[i].Text.Equals(nombre))
                {
                    treeView.SelectedNode = x[i];
                    encontrado = true;
                }
                ++i;
            }
            treeView.SelectedNode.Remove();
        }

        //recibe un string con una fecha y la transforma al formato gringo
        private String convFechaAGringa(String fecha)
        {
            StringBuilder retorno = new StringBuilder(fecha);
            //guardo los días para hacer el intercambio: 24/07/09 ==> 07/24/09
            char dia0 = retorno[0];
            char dia1 = retorno[1];

            retorno[0] = retorno[3];
            retorno[1] = retorno[4];
            retorno[3] = dia0;
            retorno[4] = dia1;

            return fecha;//retorno.ToString();
        }

        //Variables globales
        private InterfazPrincipal Principal;


    }
}
